#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;


//对象的初始化用构造函数，对象的清理用析构函数（如果不写，编译器会自动提供空实现）
//构造函数：在创建对象时为对象的成员属性赋值，由编译器自动调用，无须手动调用
//析构函数：在对象销毁前系统自动调用，执行一些清理工作

//构造函数语法： 类名(){}
//1.没有返回值，也不写void
//2.函数名称和类的名称相同
//3.可以有参数，可以发生重载
//4.程序调用对象时会自动调用构造函数，不用手动调用，而且只会调用一次

//析构函数语法：~类名(){}
//1.同构造函数
//2.函数名就是类名前面再加一个~
//3.不可以有参数，不会发生重载
//4.程序在对象销毁前会自动调用析构函数，......

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person构造函数的调用。" << endl;
	}

	//析构函数
	~Person()
	{
		cout << "Person析构函数的调用。" << endl;
	}
};

void test01()
{
	Person p; //创建对象，此时自动调用一次构造函数
			  //在栈区的数据，test01执行完毕后自动销毁，此时调用一次析构函数
}

int main()
{
	//test01();

	Person p1;			//创建对象p1
	system("pause");	//按任意键过后才会销毁p1对象。
	return 0;
}
*/





//构造函数的分类及调用

//按参数分类：	有参构造和无参构造(无参构造又叫默认构造)
//按类型分类：	普通构造和拷贝构造
//三种调用方法：括号法， 显示法， 隐式转换法

class Person
{
public:
	
	string name;
	int age ;

	Person()
	{
		cout << "Person的无参构造函数调用" << endl;
	}
	Person(int a)
	{
		age = a;
		cout << "Person的有参构造函数调用" << endl;
	}

	//拷贝构造函数
	Person(const Person &p) //有const,且以引用的方式拷贝
	{
		//将传入的对象的属性拷贝
		age = p.age;
		cout << "Person的拷贝构造函数调用" << endl;
	}

	~Person()
	{
		cout << "Person析构函数调用" << endl;
	}
};

//调用
void test01()
{
	//括号法
	Person p1;		//默认构造的调用
	Person p2(10);	//有参构造函数的调用
	Person p3(p2);	//拷贝构造函数的调用

	cout << "p2的年龄为: " << p2.age << endl;
	cout << "p3的年龄为: " << p3.age << endl;
	//注意事项:
	//调用默认构造创建对象时不要加括号，加了括号会被认为是函数的声明
	

	//显示法
	Person a1 = Person(12);		//有参构造
	Person a2 = Person(a1);		//拷贝构造
	//等号右边的格式叫匿名对象，当前行执行结束后系统会立即回收匿名对象
	//即立即调用析构函数
	//注意事项：
	//		不要利用拷贝构造函数来初始化匿名对象 即Person(a1);会被认为对象声明

	//隐式转换法
	Person p4 = 19; //相当于 Person p4 = Person(10);	有参构造
	Person p5 = p4;	//拷贝构造
}

int main()
{
	test01();
	system("pause");
	return 0;
}



//拷贝构造函数使用时机:
//1.使用一个已经创建完毕的对象来初始化一个新对象
//2.值传递的方式给函数参数传值
//3.以值方式返回局部对象

class Person
{
public:
	int m_Age;
	Person()
	{
		cout << "Person默认构造函数调用" << endl;
	}

	Person(int age)
	{
		cout << "Person有参构造函数调用" << endl;
		m_Age = age;
	}

	Person(const Person& p)
	{
		cout << "Person拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
	}

	~Person()
	{
		cout << "Person析构函数调用" << endl;
	}
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为: " << p2.m_Age << endl;
}

//2.值传递的方式给函数参数传值
void doWork(Person p)//值传递就等于拷贝一个副本
{					 //值传递也就会调用拷贝构造函数

}

void test02()
{
	Person p;
	doWork(p);
}

//3.以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;  //返回值为p1,类型为Person，也就会根据p1创建一个新的类，即拷贝
}

void test03()
{
	Person p = doWork2();
	cout << (int*)&p << endl;
}

int main()
{
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}



//构造函数调用规则
/*
默认情况下，c++编译器至少给一个类添加3个函数
1.默认构造函数（无参， 函数体为空）
2.默认析构函数（无参， 函数体为空）
3.默认拷贝函数，自动对所有属性进行值拷贝

调用规则如下：
	如果用户定义有参构造函数，cpp不再提供默认无参构造函数，继续提供默认拷贝函数
	如果用户定义拷贝构造函数，cpp不再提供其他构造函数
	即（拷贝一定有）
*/


//深拷贝与浅拷贝
//浅拷贝：简单的赋值拷贝操作
//深拷贝：在堆区重新申请空间，进行拷贝操作

class Person
{
public:
	int m_Age;		//年龄
	int* m_Height;	//身高
	Person()
	{
		cout << "Person默认构造函数调用" << endl;
	}

	Person(int age, int height)
	{
		cout << "Person有参构造函数调用" << endl;
		m_Age = age;
		m_Height = new int(height);
	}
	//深拷贝
	Person(const Person &p)
	{
		cout << "Person拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
		//m_Height = p.m_Height;	//编译器提供的浅拷贝这样写
		m_Height = new int(*p.m_Height);
	}

	~Person()
	{
		//析构代码，将堆区开辟数据做释放
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
		cout << "Person析构函数调用" << endl;
	}
};

void test01()
{
	//栈区内存先进后出， 即先申请的后释放
	Person p1(18, 170);
	
	cout << "p1的年龄为： " << p1.m_Age << "身高为：" << *p1.m_Height <<endl;

	Person p2(p1); //若编译器自带的拷贝函数，浅拷贝，容易造成堆区内存重复释放

	cout << "p2的年龄为： " << p2.m_Age << "身高为：" << *p1.m_Height << endl;
}


int main()
{
	test01();
	return 0;
}
//如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来问题.




//初始化列表
//和构造函数一样，用来初始化属性，初始化列表是调用的拷贝构造函数，初始化和赋值为一步操作，效率更高
//不采用初始化列表调用的是普通构造函数，初始化和赋值分为两步操作
//语法 :
//		构造函数():属性1(值1),属性2(值2)...{}

class Person
{
public:
	int m_A;
	int m_B;
	int m_C;

	//传统构造函数初始化
	//Person(int a, int b, int c)
	//{
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表初始化属性
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
	{

	}

};

void test01()
{
	//Person p(10, 20, 30);
	Person p(23, 12, 24);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}

int main()
{
	test01();
	return 0;
}
//初始化列表的应用
//主要是其初始化和定义是同时完成。当成员变量是引用或者const修饰的常量时，变量的定义和初始化要求同时进行，此时必须用初始化列表。











//类对象作为类成员

class Phone
{
public:
	string m_PName;
	Phone(string PName)
	{
		cout << "Phone构造函数调用" << endl;
		m_PName = PName;
	}
	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}
};

class Person
{
public:
	string m_Name;
	Phone m_Phone;

	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
};

void test01()
{
	Person p("张三", "苹果MAX");
	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
}

int main()
{
	test01();
}
//结论:当其他类对象作为本类成员时，构造时先构造其他类对象再构造本类。
//	   析构销毁时，先销毁本类对象，再销毁其他类对象





//静态成员 （静态成员也受访问权限限制）
//静态成员就是再成员变量和成员函数前加关键字 static
/*
	1.静态成员变量
	所有对象共享同一份数据
	在编译阶段分配内存(在全局区)
	类内声明，类外初始化(必须这样，否则报错)

	2.静态成员函数
	所有对象共享同一个函数
	静态成员函数只能访问静态成员变量
*/

class Person
{
public:
	static int m_A;		//类内声明
	int m_a ;
	static void func()
	{
		m_A = 11;		//可以访问
		//m_a = 12;		//静态成员函数不能访问非静态成员变量
		cout << "static void func()函数调用" << endl;
	}
private:
	static int m_B;		//静态成员变量也有权限限制

};

int Person::m_B = 200;
int Person::m_A = 100;	//类外初始化

void test01()
{
	Person p;
	cout << p.m_A << endl;

	Person p2;
	p2.m_A = 200;	//p2对象内修改为200后，p1对象内m_A也为200，所有对象共享同一份数据
	cout << p.m_A << endl;
}

void test02()
{
	//静态成员变量不属于某一个对象，时所有对象共享的同一份数据
	//因此静态成员变量有两种访问方式

	//1.通过对象进行访问
	Person p;
	cout << p.m_A << endl;
	//2.通过类名进行访问
	cout << Person::m_A << endl;	//::表示Person作用域下的m_A;
}

void test03()
{
	//静态成员函数两种调用方法

	//1.通过对象访问
	Person p;
	p.func();

	//2.通过类名访问
	Person::func();
}

int main()
{
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}







